home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / dviware / dvitovdu32 / src / pascal / vt220vdu.p < prev    next >
Text File  |  1991-11-10  |  9KB  |  308 lines
  1. (* VDU routines for a VT220 terminal. *)
  2.  
  3. #include 'globals.h';
  4. #include 'screenio.h';
  5. #include 'vdu.h';
  6.  
  7. CONST
  8.    SO = CHR(16b);
  9.    SI = CHR(17b);
  10.  
  11. CONST
  12.    hpixels = 1;        (* horizontal pixels per char position *)
  13.    vpixels = 5;        (* vertical pixels per char position *)
  14.    flag    = 7;
  15.    hscreenmax = 131;   (* max horizontal char coordinate *)
  16.    vscreenmax = 23;    (* max vertical char coordinate *)
  17.  
  18. VAR
  19.    cursrow, curscol : INTEGER;   (* ShowChar remembers cursor location *)
  20.    rectcount : INTEGER;          (* keeps a count of ShowRectangle calls;
  21.                                     reset in ShowBitmap *)
  22.    Bitmap : ARRAY [0..hscreenmax, 0..vscreenmax] OF bytes_or_bits;
  23.  
  24. (******************************************************************************)
  25.  
  26. PROCEDURE MoveAbs (row, col : INTEGER);
  27.  
  28. (* Move cursor to given screen position. *)
  29.  
  30. BEGIN
  31. WriteChar(ESC); WriteChar('[');
  32. WriteInt(row);
  33. WriteChar(';');
  34. WriteInt(col);
  35. WriteChar('H');
  36. END; (* MoveAbs *)
  37.  
  38. (******************************************************************************)
  39.  
  40. PROCEDURE MoveQuick (screenh, screenv : INTEGER);
  41.  
  42. (* Move cursor to given screen position.
  43.    We remember the cursor position (cursrow,curscol) so we can reduce the
  44.    output bytes needed to do the next MoveQuick.
  45.    StartGraphics resets the position to an undefined state (cursrow = 0).
  46.    We also reset when the cursor reaches the right edge (= windowwd) to
  47.    avoid possibility of any auto wrap.
  48. *)
  49.  
  50. VAR amount : INTEGER;
  51.  
  52. BEGIN
  53. (* first translate DVItoVDU coordinates into actual screen location *)
  54. screenh := screenh + 1;
  55. screenv := screenv + 1;
  56. IF cursrow = screenv THEN BEGIN
  57.    (* The cursor is on the same line as in previous MoveQuick call so we only
  58.       need to move left or right, and probably just a small amount (if at all).
  59.    *)
  60.    IF screenh = curscol THEN       (* cursor in correct location *)
  61.       curscol := curscol + 1       (* cursor will move right when ch written *)
  62.    ELSE IF screenh < curscol THEN BEGIN
  63.       (* move cursor left *)
  64.       amount := curscol - screenh;
  65.       WriteChar(ESC); WriteChar('[');
  66.       IF amount > 1 THEN BEGIN     (* default is 1 col *)
  67.          WriteInt(amount);
  68.          curscol := curscol - (amount-1);
  69.       END;
  70.       WriteChar('D');
  71.    END
  72.    ELSE BEGIN                      (* move cursor right *)
  73.       amount := screenh - curscol;
  74.       WriteChar(ESC); WriteChar('[');
  75.       IF amount > 1 THEN WriteInt(amount);   (* default is 1 col *)
  76.       curscol := curscol + (amount+1);
  77.       WriteChar('C');
  78.    END;
  79. END
  80. ELSE BEGIN                         (* cursrow undefined or ch on a new line *)
  81.    MoveAbs(screenv,screenh);
  82.    cursrow := screenv;
  83.    curscol := screenh + 1;         (* cursor will move right when ch written *)
  84. END;
  85. IF screenh = windowwd THEN         (* ch will be written at right edge *)
  86.    cursrow := 0;                   (* so avoid auto wrap next time around *)
  87. END; (* MoveQuick *)
  88.  
  89. (******************************************************************************)
  90.  
  91. PROCEDURE ClearBitmap;
  92.  
  93. (* Clear the Bitmap. *)
  94.  
  95. VAR h, v : INTEGER;
  96.  
  97. BEGIN
  98. FOR v := 4 TO vscreenmax DO     (* ignore dialogue lines 0..3 *)
  99.    FOR h := 0 TO hscreenmax DO
  100.       Bitmap[h,v].bits := [];
  101. END; (* ClearBitmap *)
  102.  
  103. (******************************************************************************)
  104.  
  105. PROCEDURE ShowBitmap;
  106.  
  107. (* Display only the flagged characters in the Bitmap. *)
  108.  
  109. VAR h, v : INTEGER;
  110.  
  111. BEGIN
  112. WriteChar(SO);   (* assume only working over 7 bit comm lines *)
  113. FOR v := 4 TO vscreenmax DO                     (* ignore dialogue lines *)
  114.    FOR h := 0 TO hscreenmax DO
  115.       IF flag IN Bitmap[h,v].bits THEN BEGIN    (* send flagged character *)
  116.          Bitmap[h,v].bits := Bitmap[h,v].bits - [flag];   (* clear flag *)
  117.          MoveQuick(h,v);
  118.          WriteChar(CHR(ORD(Bitmap[h,v].ch[0]) + 32));
  119.       END;
  120. WriteChar(SI);   (* assume only working over 7 bit comm lines *)
  121. WriteBuffer;
  122. rectcount := 0;
  123. END; (* ShowBitmap *)
  124.  
  125. (******************************************************************************)
  126.  
  127. PROCEDURE StartText;
  128.  
  129. (* We are about to draw text in dialogue region. *)
  130.  
  131. BEGIN
  132. ShowBitmap;
  133. END; (* StartText *)
  134.  
  135. (******************************************************************************)
  136.  
  137. PROCEDURE MoveToTextLine (line : INTEGER);
  138.  
  139. (* Move current position to start of given line. *)
  140.  
  141. BEGIN
  142. MoveAbs(line,1);
  143. END; (* MoveToTextLine *)
  144.  
  145. (******************************************************************************)
  146.  
  147. PROCEDURE ClearTextLine (line : INTEGER);
  148.  
  149. (* Erase given line; note that DVItoVDU does not assume anything about the
  150.    current position at the end of this routine.
  151. *)
  152.  
  153. BEGIN
  154. MoveAbs(line,1);
  155. WriteChar(ESC);
  156. WriteString('[K');   (* erase to end of line *)
  157. END; (* ClearTextLine *)
  158.  
  159. (******************************************************************************)
  160.  
  161. PROCEDURE ClearScreen;
  162.  
  163. BEGIN
  164. WriteChar(ESC);
  165. WriteString('[2J');   (* erase entire screen *)
  166. ClearBitmap;          (* reset Bitmap *)
  167. END; (* ClearScreen *)
  168.  
  169. (******************************************************************************)
  170.  
  171. PROCEDURE StartGraphics;
  172.  
  173. (* We are about to draw in window region. *)
  174.  
  175. BEGIN
  176. rectcount := 0;
  177. cursrow := 0;   (* for MoveQuick *)
  178. END; (* StartGraphics *)
  179.  
  180. (******************************************************************************)
  181.  
  182. PROCEDURE LoadFont (fontname : string;
  183.                     fontsize : INTEGER;
  184.                     mag, hscale, vscale : REAL);
  185.  
  186. BEGIN
  187. (* only one character size available on VT220s, so do nothing *)
  188. END; (* LoadFont *)
  189.  
  190. (******************************************************************************)
  191.  
  192. PROCEDURE ShowChar (screenh, screenv : INTEGER;
  193.                     ch : CHAR);
  194.  
  195. (* Show the given Terse character (mapped to ASCII) at the given position. *)
  196.  
  197. BEGIN
  198. IF rectcount > 0 THEN   (* flush Bitmap if ShowRectangle/s are pending *)
  199.    ShowBitmap;
  200. MoveQuick(screenh, screenv DIV vpixels);
  201. WriteChar(TeXtoASCII[ch]);
  202. END; (* ShowChar *)
  203.  
  204. (******************************************************************************)
  205.  
  206. PROCEDURE ShowRectangle (screenh, screenv,          (* top left pixel *)
  207.                          width, height : INTEGER;   (* size of rectangle *)
  208.                          ch : CHAR);                (* black pixel *)
  209.  
  210. (* Set the given rectangular Bitmap region.
  211.    DVItoVDU ensures the top left position is visible and the given
  212.    dimensions do not go beyond the window edges.
  213. *)
  214.  
  215. VAR h, v, vrow : INTEGER;
  216.  
  217. BEGIN
  218. FOR v := screenv TO screenv + height - 1 DO
  219.     FOR h := screenh TO screenh + width - 1 DO BEGIN
  220.         (* set bit h,v in Bitmap *)
  221.         vrow := v DIV vpixels;
  222.         (* include flag so char will be sent *)
  223.         Bitmap[h,vrow].bits := Bitmap[h,vrow].bits + [v MOD vpixels, flag];
  224.     END;
  225. rectcount := rectcount + 1;
  226. IF rectcount = 400 THEN   (* avoid too much of a pause before flushing Bitmap *)
  227.    ShowBitmap;
  228. END; (* ShowRectangle *)
  229.  
  230. (******************************************************************************)
  231.  
  232. PROCEDURE LoadPixels;
  233.  
  234. (* Down-load the chunky graphics character set into the VT220. *)
  235.  
  236. BEGIN
  237. WriteChar(ESC); WriteChar('P');
  238. WriteString('1;1;2;3;2;1{&%C');
  239. WriteString('BBBBBBBB/????????;');
  240. WriteString('KKKKKKKK/????????;');
  241. WriteString('NNNNNNNN/????????;');
  242. WriteString('oooooooo/????????;');
  243. WriteString('rrrrrrrr/????????;');
  244. WriteString('{{{{{{{{/????????;');
  245. WriteString('~~~~~~~~/????????;');
  246. WriteString('????????/BBBBBBBB;');
  247. WriteString('BBBBBBBB/BBBBBBBB;');
  248. WriteString('KKKKKKKK/BBBBBBBB;');
  249. WriteString('NNNNNNNN/BBBBBBBB;');
  250. WriteString('oooooooo/BBBBBBBB;');
  251. WriteString('rrrrrrrr/BBBBBBBB;');
  252. WriteString('{{{{{{{{/BBBBBBBB;');
  253. WriteString('~~~~~~~~/BBBBBBBB;');
  254. WriteString('????????/KKKKKKKK;');
  255. WriteString('BBBBBBBB/KKKKKKKK;');
  256. WriteString('KKKKKKKK/KKKKKKKK;');
  257. WriteString('NNNNNNNN/KKKKKKKK;');
  258. WriteString('oooooooo/KKKKKKKK;');
  259. WriteString('rrrrrrrr/KKKKKKKK;');
  260. WriteString('{{{{{{{{/KKKKKKKK;');
  261. WriteString('~~~~~~~~/KKKKKKKK;');
  262. WriteString('????????/NNNNNNNN;');
  263. WriteString('BBBBBBBB/NNNNNNNN;');
  264. WriteString('KKKKKKKK/NNNNNNNN;');
  265. WriteString('NNNNNNNN/NNNNNNNN;');
  266. WriteString('oooooooo/NNNNNNNN;');
  267. WriteString('rrrrrrrr/NNNNNNNN;');
  268. WriteString('{{{{{{{{/NNNNNNNN;');
  269. WriteString('~~~~~~~~/NNNNNNNN');
  270. WriteChar(ESC); WriteChar(CHR(134b));   (* ESC \ *)
  271. WriteChar(ESC); WriteString(')&%C');    (* set as G1 character set *)
  272. END; (* LoadPixels *)
  273.  
  274. (******************************************************************************)
  275.  
  276. PROCEDURE ResetVDU;
  277.  
  278. (* We don't do a hardware reset, but leave VDU in 80 column mode. *)
  279.  
  280. BEGIN
  281. WriteChar(ESC); WriteString('[?3l');    (* 80 column mode *)
  282. END; (* ResetVDU *)
  283.  
  284. (******************************************************************************)
  285.  
  286. PROCEDURE InitVDU;
  287.  
  288. (* The dialogue region is the top 4 lines.
  289.    The window region is the remaining area of the screen
  290.    (the bottom 20 rows in Bitmap).
  291. *)
  292.  
  293. BEGIN
  294. DVIstatusl    := 1;
  295. windowstatusl := 2;
  296. messagel      := 3;
  297. commandl      := 4;
  298. bottoml       := vscreenmax + 1;
  299. (* DVItoVDU's coordinate scheme is the same as the VT220 scheme. *)
  300. windowh  := 0;
  301. windowv  := 4 * vpixels;                (* = height of 4 dialogue lines *)
  302. windowwd := (hscreenmax + 1) * hpixels;
  303. windowht := (vscreenmax + 1) * vpixels - windowv;
  304.  
  305. LoadPixels;
  306. WriteChar(ESC); WriteString('[?3h');    (* 132 column mode *)
  307. END; (* InitVDU *)
  308.